home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 5 / Apprentice-Release5.iso / Source Code / Libraries / WASTE 1.2 / WEPascalPPCGlue.p < prev   
Text File  |  1996-06-11  |  11KB  |  287 lines
  1. unit WEPascalPPCGlue;
  2.  
  3. { WASTE Pascal PPC glue code }
  4. { version 1.2 (June 1996) }
  5.  
  6. { RATIONALE: the NewWE≈Proc calls used to create routine descriptors   }
  7. {  for several WASTE callbacks are defined as actual entry points in   }
  8. {  WASTE.p (if generating code for the PPC), but in the C code they're }
  9. {  really only macros.  So when you link a PPC Pascal program to a     }
  10. {  WASTE library built from C code, you'll want to include this glue   }
  11. {  file to avoid link errors.                                          }
  12.  
  13. { Copyright © 1993-1996 Marco Piovanelli }
  14. { All Rights Reserved }
  15.  
  16. interface
  17.     uses
  18.         WASTE;
  19.  
  20. implementation
  21.  
  22. {$IFC GENERATINGCFM}
  23. {$PUSH}
  24. {$Z+}
  25.  
  26.     function NewWEClickLoopProc (userRoutine: WEClickLoopProcPtr): WEClickLoopUPP;
  27.     begin
  28.         NewWEClickLoopProc := NewRoutineDescriptor(userRoutine, uppWEClickLoopProcInfo, GetCurrentArchitecture);
  29.     end;  { NewWEClickLoopProc }
  30.  
  31.     function NewWEScrollProc (userRoutine: WEScrollProcPtr): WEScrollUPP;
  32.     begin
  33.         NewWEScrollProc := NewRoutineDescriptor(userRoutine, uppWEScrollProcInfo, GetCurrentArchitecture);
  34.     end;  { NewWEScrollProc }
  35.  
  36.     function NewWETSMPreUpdateProc (userRoutine: WETSMPreUpdateProcPtr): WETSMPreUpdateUPP;
  37.     begin
  38.         NewWETSMPreUpdateProc := NewRoutineDescriptor(userRoutine, uppWETSMPreUpdateProcInfo, GetCurrentArchitecture);
  39.     end;  { NewWETSMPreUpdateProc }
  40.  
  41.     function NewWETSMPostUpdateProc (userRoutine: WETSMPostUpdateProcPtr): WETSMPostUpdateUPP;
  42.     begin
  43.         NewWETSMPostUpdateProc := NewRoutineDescriptor(userRoutine, uppWETSMPostUpdateProcInfo, GetCurrentArchitecture);
  44.     end;  { NewWETSMPostUpdateProc }
  45.  
  46.     function NewWETranslateDragProc (userRoutine: WETranslateDragProcPtr): WETranslateDragUPP;
  47.     begin
  48.         NewWETranslateDragProc := NewRoutineDescriptor(userRoutine, uppWETranslateDragProcInfo, GetCurrentArchitecture);
  49.     end;  { NewWETranslateDragProc }
  50.  
  51.     function NewWEHiliteDropAreaProc (userRoutine: WEHiliteDropAreaProcPtr): WEHiliteDropAreaUPP;
  52.     begin
  53.         NewWEHiliteDropAreaProc := NewRoutineDescriptor(userRoutine, uppWEHiliteDropAreaProcInfo, GetCurrentArchitecture);
  54.     end;  { NewWEHiliteDropAreaProc }
  55.  
  56.     function NewWEDrawTextProc (userRoutine: WEDrawTextProcPtr): WEDrawTextUPP;
  57.     begin
  58.         NewWEDrawTextProc := NewRoutineDescriptor(userRoutine, uppWEDrawTextProcInfo, GetCurrentArchitecture);
  59.     end;  { NewWEDrawTextProc }
  60.  
  61.     function NewWEPixelToCharProc (userRoutine: WEPixelToCharProcPtr): WEPixelToCharUPP;
  62.     begin
  63.         NewWEPixelToCharProc := NewRoutineDescriptor(userRoutine, uppWEPixelToCharProcInfo, GetCurrentArchitecture);
  64.     end;  { NewWEPixelToCharProc }
  65.  
  66.     function NewWECharToPixelProc (userRoutine: WECharToPixelProcPtr): WECharToPixelUPP;
  67.     begin
  68.         NewWECharToPixelProc := NewRoutineDescriptor(userRoutine, uppWECharToPixelProcInfo, GetCurrentArchitecture);
  69.     end;  { NewWECharToPixelProc }
  70.  
  71.     function NewWELineBreakProc (userRoutine: WELineBreakProcPtr): WELineBreakUPP;
  72.     begin
  73.         NewWELineBreakProc := NewRoutineDescriptor(userRoutine, uppWELineBreakProcInfo, GetCurrentArchitecture);
  74.     end;  { NewWELineBreakProc }
  75.  
  76.     function NewWEWordBreakProc (userRoutine: WEWordBreakProcPtr): WEWordBreakUPP;
  77.     begin
  78.         NewWEWordBreakProc := NewRoutineDescriptor(userRoutine, uppWEWordBreakProcInfo, GetCurrentArchitecture);
  79.     end;  { NewWEWordBreakProc }
  80.  
  81.     function NewWECharByteProc (userRoutine: WECharByteProcPtr): WECharByteUPP;
  82.     begin
  83.         NewWECharByteProc := NewRoutineDescriptor(userRoutine, uppWECharByteProcInfo, GetCurrentArchitecture);
  84.     end;  { NewWECharByteProc }
  85.  
  86.     function NewWECharTypeProc (userRoutine: WECharTypeProcPtr): WECharTypeUPP;
  87.     begin
  88.         NewWECharTypeProc := NewRoutineDescriptor(userRoutine, uppWECharTypeProcInfo, GetCurrentArchitecture);
  89.     end;  { NewWECharTypeProc }
  90.  
  91.     function NewWENewObjectProc (userRoutine: WENewObjectProcPtr): WENewObjectUPP;
  92.     begin
  93.         NewWENewObjectProc := NewRoutineDescriptor(userRoutine, uppWENewObjectProcInfo, GetCurrentArchitecture);
  94.     end;  { NewWENewObjectProc }
  95.  
  96.     function NewWEDisposeObjectProc (userRoutine: WEDisposeObjectProcPtr): WEDisposeObjectUPP;
  97.     begin
  98.         NewWEDisposeObjectProc := NewRoutineDescriptor(userRoutine, uppWEDisposeObjectProcInfo, GetCurrentArchitecture);
  99.     end;  { NewWEDisposeObjectProc }
  100.  
  101.     function NewWEDrawObjectProc (userRoutine: WEDrawObjectProcPtr): WEDrawObjectUPP;
  102.     begin
  103.         NewWEDrawObjectProc := NewRoutineDescriptor(userRoutine, uppWEDrawObjectProcInfo, GetCurrentArchitecture);
  104.     end;  { NewWEDrawObjectProc }
  105.  
  106.     function NewWEClickObjectProc (userRoutine: WEClickObjectProcPtr): WEClickObjectUPP;
  107.     begin
  108.         NewWEClickObjectProc := NewRoutineDescriptor(userRoutine, uppWEClickObjectProcInfo, GetCurrentArchitecture);
  109.     end;  { NewWEClickObjectProc }
  110.     
  111.     function NewWEStreamObjectProc (userRoutine: WEStreamObjectProcPtr): WEStreamObjectUPP;
  112.     begin
  113.         NewWEStreamObjectProc := NewRoutineDescriptor(userRoutine, uppWEStreamObjectProcInfo, GetCurrentArchitecture);
  114.     end;  { NewWEStreamObjectProc }
  115.  
  116.     function CallWEClickLoopProc (we: WEReference;
  117.                                     userRoutine: WEClickLoopUPP): Boolean;
  118.     begin
  119.         CallWEClickLoopProc := Boolean(CallUniversalProc(userRoutine, uppWEClickLoopProcInfo, we));
  120.     end;  { CallWEClickLoopProc }
  121.  
  122.     procedure CallWEScrollProc (we: WEReference;
  123.                                     userRoutine: WEScrollUPP);
  124.         var
  125.             retval: LongInt;
  126.     begin
  127.         retval := CallUniversalProc(userRoutine, uppWEScrollProcInfo, we);
  128.     end;  { CallWEScrollProc }
  129.  
  130.     procedure CallWETSMPreUpdateProc (we: WEReference;
  131.                                     userRoutine: WETSMPreUpdateUPP);
  132.         var
  133.             retval: LongInt;
  134.     begin
  135.         retval := CallUniversalProc(userRoutine, uppWETSMPreUpdateProcInfo, we);
  136.     end;  { CallWETSMPreUpdateProc }
  137.  
  138.     procedure CallWETSMPostUpdateProc (we: WEReference;
  139.                                     fixLength: LongInt;
  140.                                     inputAreaStart, inputAreaEnd: LongInt;
  141.                                     pinRangeStart, pinRangeEnd: LongInt;
  142.                                     userRoutine: WETSMPostUpdateUPP);
  143.         var
  144.             retval: LongInt;
  145.     begin
  146.         retval := CallUniversalProc(userRoutine, uppWETSMPostUpdateProcInfo, we, fixLength, inputAreaStart, inputAreaEnd, pinRangeStart, pinRangeEnd);
  147.     end;  { CallWETSMPostUpdateProc }
  148.  
  149.     function CallWETranslateDragProc (theDrag: DragReference;
  150.                                     theItem: ItemReference;
  151.                                     requestedType: FlavorType;
  152.                                     putDataHere: Handle;
  153.                                     userRoutine: WETranslateDragUPP): OSErr;
  154.     begin
  155.         CallWETranslateDragProc := CallUniversalProc(userRoutine, uppWETranslateDragProcInfo, theDrag, theItem, requestedType, putDataHere);
  156.     end;  { CallWETranslateDragProc }
  157.  
  158.     function CallWEHiliteDropAreaProc (theDrag: DragReference;
  159.                                     hiliteFlag: Boolean;
  160.                                     we: WEReference;
  161.                                     userRoutine: WEHiliteDropAreaUPP): OSErr;
  162.     begin
  163.         CallWEHiliteDropAreaProc := CallUniversalProc(userRoutine, uppWEHiliteDropAreaProcInfo, theDrag, hiliteFlag, we);
  164.     end;  { CallWEHiliteDropAreaProc }
  165.  
  166.     procedure CallWEDrawTextProc (pText: Ptr;
  167.                                     textLength: LongInt;
  168.                                     slop: Fixed;
  169.                                     styleRunPosition: JustStyleCode;
  170.                                     we: WEReference;
  171.                                     userRoutine: WEDrawTextUPP);
  172.         var
  173.             retval: LongInt;
  174.     begin
  175.         retval := CallUniversalProc(userRoutine, uppWEDrawTextProcInfo, pText, textLength, slop, styleRunPosition, we);
  176.     end;  { CallWEDrawTextProc }
  177.  
  178.     function CallWEPixelToCharProc (pText: Ptr;
  179.                                     textLength: LongInt;
  180.                                     slop: Fixed;
  181.                                     var width: Fixed;
  182.                                     var edge: SignedByte;
  183.                                     styleRunPosition: JustStyleCode;
  184.                                     hPos: Fixed;
  185.                                     we: WEReference;
  186.                                     userRoutine: WEPixelToCharUPP): LongInt;
  187.     begin
  188.         CallWEPixelToCharProc := CallUniversalProc(userRoutine, uppWEPixelToCharProcInfo, pText, textLength, slop, width, edge, styleRunPosition, hPos, we);
  189.     end;  { CallWEPixelToCharProc }
  190.  
  191.     function CallWECharToPixelProc (pText: Ptr;
  192.                                     textLength: LongInt;
  193.                                     slop: Fixed;
  194.                                     offset: LongInt;
  195.                                     direction: Integer;
  196.                                     styleRunPosition: JustStyleCode;
  197.                                     hPos: LongInt;
  198.                                     we: WEReference;
  199.                                     userRoutine: WECharToPixelUPP): Integer;
  200.     begin
  201.         CallWECharToPixelProc := CallUniversalProc(userRoutine, uppWECharToPixelProcInfo, pText, textLength, slop, offset, direction, styleRunPosition, hPos, we);
  202.     end;  { CallWECharToPixelProc }
  203.  
  204.     function CallWELineBreakProc (pText: Ptr;
  205.                                     textLength: LongInt;
  206.                                     textStart, textEnd: LongInt;
  207.                                     var textWidth: Fixed;
  208.                                     var textOffset: LongInt;
  209.                                     we: WEReference;
  210.                                     userRoutine: WELineBreakUPP): StyledLineBreakCode;
  211.     begin
  212.         CallWELineBreakProc := CallUniversalProc(userRoutine, uppWELineBreakProcInfo, pText, textLength, textStart, textEnd, textWidth, textOffset, we);
  213.     end;  { CallWELineBreakProc }
  214.  
  215.     procedure CallWEWordBreakProc (pText: Ptr;
  216.                                     textLength, offset: Integer;
  217.                                     edge: SignedByte;
  218.                                     var breakOffsets: OffsetTable;
  219.                                     script: ScriptCode;
  220.                                     we: WEReference;
  221.                                     userRoutine: WEWordBreakUPP);
  222.         var
  223.             retval: LongInt;
  224.     begin
  225.         retval := CallUniversalProc(userRoutine, uppWEWordBreakProcInfo, pText, textLength, offset, edge, breakOffsets, script, we);
  226.     end;  { CallWEWordBreakProc }
  227.  
  228.     function CallWECharByteProc (pText: Ptr;
  229.                                     textOffset: Integer;
  230.                                     script: ScriptCode;
  231.                                     we: WEReference;
  232.                                     userRoutine: WECharByteUPP): Integer;
  233.     begin
  234.         CallWECharByteProc := CallUniversalProc(userRoutine, uppWECharByteProcInfo, pText, textOffset, script, we);
  235.     end;  { CallWECharByteProc }
  236.  
  237.     function CallWECharTypeProc (pText: Ptr;
  238.                                     textOffset: Integer;
  239.                                     script: ScriptCode;
  240.                                     we: WEReference;
  241.                                     userRoutine: WECharTypeUPP): Integer;
  242.     begin
  243.         CallWECharTypeProc := CallUniversalProc(userRoutine, uppWECharTypeProcInfo, pText, textOffset, script, we);
  244.     end;  { CallWECharTypeProc }
  245.  
  246.     function CallWENewObjectProc (var defaultObjectSize: Point;
  247.                                     objectRef: WEObjectReference;
  248.                                     userRoutine: WENewObjectUPP): OSErr;
  249.     begin
  250.         CallWENewObjectProc := CallUniversalProc(userRoutine, uppWENewObjectProcInfo, defaultObjectSize, objectRef);
  251.     end;  { CallWENewObjectProc }
  252.  
  253.     function CallWEDisposeObjectProc (objectRef: WEObjectReference;
  254.                                     userRoutine: WEDisposeObjectUPP): OSErr;
  255.     begin
  256.         CallWEDisposeObjectProc := CallUniversalProc(userRoutine, uppWEDisposeObjectProcInfo, objectRef);
  257.     end;  { CallWEDisposeObjectProc }
  258.  
  259.     function CallWEDrawObjectProc ({const} var destRect: Rect;
  260.                                     objectRef: WEObjectReference;
  261.                                     userRoutine: WEDrawObjectUPP): OSErr;
  262.     begin
  263.         CallWEDrawObjectProc := CallUniversalProc(userRoutine, uppWEDrawObjectProcInfo, destRect, objectRef);
  264.     end;  { CallWEDrawObjectProc }
  265.  
  266.     function CallWEClickObjectProc (hitPoint: Point;
  267.                                     modifiers: EventModifiers;
  268.                                     clickTime: LongInt;
  269.                                     objectRef: WEObjectReference;
  270.                                     userRoutine: WEClickObjectUPP): Boolean;
  271.     begin
  272.         CallWEClickObjectProc := Boolean(CallUniversalProc(userRoutine, uppWEClickObjectProcInfo, hitPoint, modifiers, clickTime, objectRef));
  273.     end;  { CallWEClickObjectProc }
  274.  
  275.     function CallWEStreamObjectProc (destKind: Integer;
  276.                                     var theType: FlavorType;
  277.                                     putDataHere: Handle;
  278.                                     objectRef: WEObjectReference;
  279.                                     userRoutine: WEStreamObjectUPP): OSErr;
  280.     begin
  281.         CallWEStreamObjectProc := CallUniversalProc(userRoutine, uppWEStreamObjectProcInfo, destKind, theType, putDataHere, objectRef);
  282.     end;  { CallWEStreamObjectProc }
  283.  
  284. {$POP}
  285. {$ENDC}
  286.  
  287. end.